package regexp;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author DCSGO
 * @version 1.0
 * 正则表达式实现细节
 */
public class RegTheory {
    public static void main(String[] args) {
        String content = ReadContent.getContent("src\\content.txt");
        System.out.println("content.length() = " + content.length());
        //查找 content 中所有4位数字
        //1.创建一个 模式对象(正则表达式对象)
        String regex = "(\\d\\d)(\\d\\d)";//正则表达式 \\d 代表1位数字
        Pattern pattern = Pattern.compile(regex);
        //2.创建一个 匹配器 这个匹配器通过 pattern
        //  的正则表达式来匹配 content 中的内容
        Matcher matcher = pattern.matcher(content);
        //matcher.text -> 引用的 content
        //matcher.first -> 匹配到的子串的开始下标(content中的)
        //matcher.last -> 匹配到的子串的结束下标+1(content中的) +1 是为了便于字符串的拼接
        //matcher.oldLast -> 上一个匹配到的子串的结束下标+1 也就是下一次匹配的开始下标
        //matcher.groups -> int[] 默认大小是20 初始化为 -1 用于存放匹配到的子字符串的相关下标信息
        //matcher.from -> text中文本的起始下标
        //matcher.to -> text中文本的起始结束下标+1


        //3.查找
        /*
         * public boolean find() {
         *         int nextSearchIndex = last;
         *         if (nextSearchIndex == first)
         *             nextSearchIndex++;
         *
         *         // If next search starts before region, start it at region
         *         // 如果下一次搜索在区域之前开始，则从区域开始
         *         if (nextSearchIndex < from)
         *             nextSearchIndex = from;
         *
         *         // If next search starts beyond region then it fails
         *         // 如果下一次搜索开始于区域之外，则失败
         *         if (nextSearchIndex > to) {
         *             for (int i = 0; i < groups.length; i++)
         *                 groups[i] = -1;
         *             return false;
         *         }
         *         return search(nextSearchIndex);
         *     }
         *
         * boolean search(int from) {
         *          //开始当前匹配的准备工作
         *         this.hitEnd = false;
         *         this.requireEnd = false;
         *         from        = from < 0 ? 0 : from;
         *         this.first  = from;
         *         this.oldLast = oldLast < 0 ? from : oldLast;
         *         for (int i = 0; i < groups.length; i++)
         *             groups[i] = -1;
         *         acceptMode = NOANCHOR;
         *         //得到结果 是否找到匹配的字符串
         *         boolean result = parentPattern.root.match(this, from, text);
         *         if (!result)
         *             this.first = -1;
         *         this.oldLast = this.last;
         *         return result;
         *     }
         *
         *  boolean match(Matcher matcher, int i, CharSequence seq) {
         *             if (i > matcher.to - minLength) {
         *                 matcher.hitEnd = true;
         *                 return false;
         *             }
         *             int guard = matcher.to - minLength;
         *             for (; i <= guard; i++) {
         *                   //真正进行匹配的方法
         *                 if (next.match(matcher, i, seq)) {
         *                      //匹配到了！修改相关下标
         *                     matcher.first = i;
         *                     matcher.groups[0] = matcher.first;
         *                     matcher.groups[1] = matcher.last;
         *                     return true;
         *                 }
         *             }
         *             matcher.hitEnd = true;
         *             return false;
         *         }
         *
         *    next.match(matcher, i, seq)：
         *    boolean match(Matcher matcher, int i, CharSequence seq) {
         *             if (i < matcher.to) {
         *                 return isSatisfiedBy(seq.charAt(i)) //当前字符是合法的
         *                     && next.match(matcher, i+1, seq);
         *             } else {
         *                 matcher.hitEnd = true;
         *                 return false;
         *             }
         *         }
         */
        for (int i = 1; matcher.find(); i++) {
            System.out.println(matcher.group(0) + " " + matcher.group(1) + " " + matcher.group(2));
            /*
             * public String group(int group) {
             *     ....检查语句
             *     return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
             * }
             */
            //在正则表达式中我们可以使用()对要匹配的子字符串进行分组
            //他们整体是一组然后依次是每个小组
            //matcher.group(0) -> 表示得到第0组匹配到的字符串即匹配到的子字符串整体
            //那自然1就表示第一个小分组，依此类推(没进行分组的话这样使用该方法就会出异常了)

            /*
             * content.length() = 73
             * 1996 19 96
             * 1997 19 97
             * 1998 19 98
             * 1999 19 99
             *
             * 进程已结束，退出代码为 0
             */
        }
    }
}
